package com.example.admin.utils;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.example.admin.result.ResponseResult;
import com.fasterxml.jackson.core.type.TypeReference;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;

public class ResultUtil {

    private static final Logger logger = LoggerFactory.getLogger(ResultUtil.class);

    private static final String SUCCESS_CODE = "00000";

    /**
     * 将响应结果转换为包含对象列表的ResponseResult对象。
     * @param r 响应结果对象
     * @param clazz 对象列表中元素的类类型
     * @return 包含对象列表的ResponseResult对象
     */
    public static <T, R> ResponseResult<List<T>> resultList(R r, Class<T> clazz) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), r, stackTraceElements[2].getLineNumber());
        ResponseResult<List<T>> responseResult = JsonUtil.convertJsonToObject(r.toString(), new TypeReference<ResponseResult<List<T>>>() {});
        if (SUCCESS_CODE.equals(responseResult.getCode())) {
            responseResult.setData(JSONObject.parseArray(JSONObject.toJSONString(responseResult.getData()), clazz));
        }
        return responseResult;
    }

    /**
     * 将响应结果转换为包含单个对象的ResponseResult对象。
     * @param r 响应结果对象
     * @return 包含单个对象的ResponseResult对象
     */
    public static <T, R> ResponseResult<Object> resultObject(R r) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), r, stackTraceElements[2].getLineNumber());
        ResponseResult<Object> responseResult = JsonUtil.convertJsonToObject(r.toString(), new TypeReference<ResponseResult<Object>>() {});
        return responseResult;
    }

    /**
     * 将响应结果转换为包含Map<String, List<T>>的ResponseResult对象。
     * @param r 响应结果对象
     * @param clazz Map中列表元素的类类型
     * @return 包含Map<String, List<T>>的ResponseResult对象
     */
    public static <T, R> ResponseResult<Map<String, List<T>>> resultMap(R r, Class<T> clazz) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), r, stackTraceElements[2].getLineNumber());
        ResponseResult<Map<String, List<T>>> responseResult = JsonUtil.convertJsonToObject(r.toString(), new TypeReference<ResponseResult<Map<String, List<T>>>>() {});
        if (SUCCESS_CODE.equals(responseResult.getCode())) {
            for (Map.Entry<String, List<T>> entry : responseResult.getData().entrySet()) {
                String key = entry.getKey();
                List<T> value = entry.getValue();
                responseResult.getData().put(key, JSONObject.parseArray(JSONObject.toJSONString(value), clazz));
            }
        }
        return responseResult;
    }

    /**
     * 将响应结果直接转换为对象列表。
     * @param r 响应结果对象
     * @param clazz 对象列表中元素的类类型
     * @return 对象列表
     */
    public static <T, R> List<T> resultDataList(R r, Class<T> clazz) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), r, stackTraceElements[2].getLineNumber());
        ResponseResult<List<T>> responseResult = JsonUtil.convertJsonToObject(r.toString(), new TypeReference<ResponseResult<List<T>>>() {});
        if (SUCCESS_CODE.equals(responseResult.getCode())) {
            responseResult.setData(JSONObject.parseArray(JSONObject.toJSONString(responseResult.getData()), clazz));
        }
        return responseResult.getData();
    }

    /**
     * 将响应结果直接转换为Map<String, List<T>>。
     * @param r 响应结果对象
     * @param clazz Map中列表元素的类类型
     * @return Map<String, List<T>>
     */
    public static <T, R> Map<String, List<T>> resultDataMap(R r, Class<T> clazz) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), r, stackTraceElements[2].getLineNumber());
        ResponseResult<Map<String, List<T>>> responseResult = JsonUtil.convertJsonToObject(r.toString(), new TypeReference<ResponseResult<Map<String, List<T>>>>() {});
        if (SUCCESS_CODE.equals(responseResult.getCode())) {
            for (Map.Entry<String, List<T>> entry : responseResult.getData().entrySet()) {
                String key = entry.getKey();
                List<T> value = entry.getValue();
                responseResult.getData().put(key, JSONObject.parseArray(JSONObject.toJSONString(value), clazz));
            }
        }
        return responseResult.getData();
    }

    /**
     * 将对象转换为指定类的对象。
     * @param t 待转换的对象
     * @param clazz 目标类类型
     * @return 转换后的对象
     */
    public static <T> T ObjectToClass(T t, Class<T> clazz) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        logger.info("{}出参：{}， 第{}行", stackTraceElements[2].getClassName(), JsonUtil.convertObjectToJson(t), stackTraceElements[2].getLineNumber());
        PropertyFilter propertyFilter = (o, s, o1) -> {
            if (o1 != null) {
                if (StringUtils.isBlank(o1.toString())) {
                    return false;
                }
            }
            return true;
        };
        return JSONObject.parseObject(JSONObject.toJSONString(t, propertyFilter), clazz);
    }

}
